@miso.ai/lorem 0.0.1

package/bin/data.js

@@ -0,0 +1,15 @@
+import { fileURLToPath } from 'url';
+import { dirname, resolve } from 'path';
+import { writeFileSync, readFileSync } from 'fs';
+import yaml from 'js-yaml';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+const WORDS_YAML = resolve(__dirname, '../data/words.yaml');
+const WORDS_JS = resolve(__dirname, '../lib/words.js');
+
+const words = yaml.load(readFileSync(WORDS_YAML, 'utf8'));
+writeFileSync(WORDS_JS, `
+// genereated by bin/data.js
+export default ${JSON.stringify(words, null, 2)};
+`);

package/data/words.yaml

@@ -0,0 +1,178 @@
+- lorem
+- ipsum
+- dolor
+- sit
+- amet
+- consectetur
+- adipiscing
+- elit
+- curabitur
+- vel
+- hendrerit
+- libero
+- eleifend
+- blandit
+- nunc
+- ornare
+- odio
+- ut
+- orci
+- gravida
+- imperdiet
+- nullam
+- purus
+- lacinia
+- a
+- pretium
+- quis
+- congue
+- praesent
+- sagittis
+- laoreet
+- auctor
+- mauris
+- non
+- velit
+- eros
+- dictum
+- proin
+- accumsan
+- sapien
+- nec
+- massa
+- volutpat
+- venenatis
+- sed
+- eu
+- molestie
+- lacus
+- quisque
+- porttitor
+- ligula
+- dui
+- mollis
+- tempus
+- at
+- magna
+- vestibulum
+- turpis
+- ac
+- diam
+- tincidunt
+- id
+- condimentum
+- enim
+- sodales
+- in
+- hac
+- habitasse
+- platea
+- dictumst
+- aenean
+- neque
+- fusce
+- augue
+- leo
+- eget
+- semper
+- mattis
+- tortor
+- scelerisque
+- nulla
+- interdum
+- tellus
+- malesuada
+- rhoncus
+- porta
+- sem
+- aliquet
+- et
+- nam
+- suspendisse
+- potenti
+- vivamus
+- luctus
+- fringilla
+- erat
+- donec
+- justo
+- vehicula
+- ultricies
+- varius
+- ante
+- primis
+- faucibus
+- ultrices
+- posuere
+- cubilia
+- curae
+- etiam
+- cursus
+- aliquam
+- quam
+- dapibus
+- nisl
+- feugiat
+- egestas
+- class
+- aptent
+- taciti
+- sociosqu
+- ad
+- litora
+- torquent
+- per
+- conubia
+- nostra
+- inceptos
+- himenaeos
+- phasellus
+- nibh
+- pulvinar
+- vitae
+- urna
+- iaculis
+- lobortis
+- nisi
+- viverra
+- arcu
+- morbi
+- pellentesque
+- metus
+- commodo
+- ut
+- facilisis
+- felis
+- tristique
+- ullamcorper
+- placerat
+- aenean
+- convallis
+- sollicitudin
+- integer
+- rutrum
+- duis
+- est
+- etiam
+- bibendum
+- donec
+- pharetra
+- vulputate
+- maecenas
+- mi
+- fermentum
+- consequat
+- suscipit
+- aliquam
+- habitant
+- senectus
+- netus
+- fames
+- quisque
+- euismod
+- curabitur
+- lectus
+- elementum
+- tempor
+- risus
+- cras

package/lib/fields.js

@@ -0,0 +1,114 @@
+import * as lorem from './lorem.js';
+import { imageUrl, sample } from './utils.js';
+import * as md from './markdown.js';
+
+const DAY = 1000 * 60 * 60 * 24;
+const WEEK = DAY * 7;
+
+export function date({} = {}) {
+  const now = Date.now();
+  const max = now - DAY;
+  const min = max - WEEK * 8;
+  return new Date(min + Math.random() * (max - min)).toISOString();
+}
+
+export function image({ size = 300 } = {}) {
+  return imageUrl(size);
+}
+
+export function authors({ size = [1, 3] } = {}) {
+  return lorem.lorem({
+    size,
+    decorates: ['title'],
+    output: 'array',
+  });
+}
+
+export function tags({ size = [1, 4] } = {}) {
+  return lorem.lorem({
+    size,
+    output: 'array',
+  });
+}
+
+// TODO: categories
+
+export function title({ size = [2, 6] } = {}) {
+  return lorem.lorem({
+    size,
+    decorates: ['title'],
+  });
+}
+
+export function term({ field }) {
+  const random = Math.random();
+  const size = random < 0.7 ? 1 : random < 0.9 ? 2 : 3;
+  return lorem.lorem({
+    size,
+    decorates: ['title'],
+  });
+}
+
+export function description({ size = [10, 20], ...options } = {}) {
+  const decorator = Object.keys(options).length ? ['description', options] : 'description';
+  return lorem.lorem({
+    size,
+    decorates: [decorator],
+  });
+}
+
+export function html({ paragraphs = 8, sections, paragraph, image: imageOptions } = {}) {
+  paragraph = {
+    size: [30, 60],
+    ...paragraph,
+  };
+  imageOptions = {
+    size: [480, 270],
+    ...imageOptions,
+  };
+  if (sections === undefined) {
+    sections = Math.floor(paragraphs * (1 + Math.random()) / 4);
+  }
+  sections = Math.max(1, Math.min(sections, paragraphs));
+  const content = [];
+  const pps = paragraphs / sections;
+  let j = 0;
+  for (let i = 0; i < sections; i++) {
+    if (i > 0) {
+      content.push(`<h4>${title()}</h4>`);
+    }
+    while (j++ < (i + 1) * pps) {
+      content.push(`<p>${description(paragraph)}</p>`);
+    }
+    content.push(`<div class="image-container"><img src="${image(imageOptions)}"></div>`);
+  }
+  return content.join('');
+}
+
+export function availability() {
+  return Math.random() > 0.3 ? 'IN_STOCK' : 'OUT_OF_STOCK';
+}
+
+export function price() {
+  return Math.floor(Math.random() * 10000) / 100;
+}
+
+export function rating() {
+  return Math.floor(Math.random() * 500) / 100 + 1;
+}
+
+export function answer({ sources, format, citation, sampling, features }) {
+  switch (format) {
+    case 'markdown':
+      let index = 1;
+      sources = sources.map(({ url }) => ({ url, index: index++ }));
+      return md.markdown({ sources, citation, sampling, features });
+    case 'plaintext':
+    default:
+      return lorem.lorem({
+        min: sample(50, sampling),
+        max: sample(50, sampling),
+        decorates: ['description'],
+      });
+  }
+}

package/lib/index.js

@@ -0,0 +1,6 @@
+import * as md from './markdown.js';
+import * as lorem from './lorem.js';
+import * as utils from './utils.js';
+import * as fields from './fields.js';
+
+export { md, lorem, utils, fields };

package/lib/languages.js

@@ -0,0 +1,162 @@
+export function javascript() {
+  return JAVASCRIPT;
+}
+
+export function js() {
+  return JAVASCRIPT;
+}
+
+const JAVASCRIPT = `
+// module
+import { a, b } from './module';
+import * as module from './module';
+import module from './module';
+export default module;
+export const a = 0;
+export * from './module';
+export * as module from './module';
+
+// variables
+let a = 10;
+const b = 20;
+
+// function declaration
+function sum(x, y) {
+  return x + y;
+}
+
+// generator function
+function* iterator() {
+  yield 0;
+  yield 1;
+}
+
+// arrow function
+const multiply = (x, y) => x * y;
+
+// class
+class Person {
+  constructor(name, age) {
+    this.name = name;
+    this.age = age;
+  }
+
+  greet() {
+    console.log('Hello, my name is Miso.');
+  }
+}
+
+// primitive
+const str = 'Hello, world!';
+const num = 10.99;
+
+// object
+const person = new Person('John', 30);
+person.greet();
+
+// object literal
+const object = {
+  name: 'John',
+  [x]: 10,
+  ...props,
+};
+
+// array literal
+const arr = [1, 2, 3, 4, 5, ...props];
+
+// regexp literal
+const regexp = /\\w+/g;
+
+// operators
+const sum = a + b;
+const product = a * b;
+const negation = -a;
+const max = a > b ? a : b;
+
+// flow control
+let i = 9;
+for (const n of arr) {
+  if (n > i) {
+    console.log(n);
+  }
+  i++;
+}
+
+// async/await
+(async () => {
+  const result = await asyncFunction();
+})();
+
+// try/catch
+try {
+} catch (e) {
+}
+
+// destructuring
+const { name, age, ...rest } = person;
+const [ x, y, ...rest ] = arr;
+
+// template literals
+${'console.log(`The sum of ${a} and ${b} is ${sum(a, b)}.`);'}
+`.trim();
+
+export function html() {
+  return HTML;
+}
+
+const HTML = `
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Sample Page</title>
+  <link rel="stylesheet" href="styles.css">
+</head>
+<body>
+  <header>
+    <nav>
+      <a href="/">Home</a>
+      <a href="/about">About</a>
+    </nav>
+  </header>
+
+  <main>
+    <h1>Welcome</h1>
+    <p>This is a <strong>sample</strong> paragraph with <em>emphasis</em>.</p>
+
+    <ul>
+      <li>Item 1</li>
+      <li>Item 2</li>
+    </ul>
+
+    <form action="/submit" method="post">
+      <label for="name">Name:</label>
+      <input type="text" id="name" name="name" required>
+      <button type="submit">Submit</button>
+    </form>
+
+    <table>
+      <thead>
+        <tr>
+          <th>Name</th>
+          <th>Value</th>
+        </tr>
+      </thead>
+      <tbody>
+        <tr>
+          <td>Alpha</td>
+          <td>100</td>
+        </tr>
+      </tbody>
+    </table>
+  </main>
+
+  <footer>
+    <p>&copy; 2024 Example</p>
+  </footer>
+
+  <script src="main.js"></script>
+</body>
+</html>
+`.trim();

package/lib/lorem.js

@@ -0,0 +1,145 @@
+import { randomInt, gaussRandom, iterateWithLastItemSignal as iterateWithLastItemSignal } from './utils.js';
+import DEFAULT_WORDS from './words.js';
+
+export function lorem({ decorates = [], output = 'string', size, min, max, ...options } = {}) {
+  let iterator = limit(size || [min, max])(base(options));
+  for (const decorate of decorates) {
+    iterator = lookup(decorate)(iterator);
+  }
+  return lookup(output)(iterator);
+}
+
+const FNS = {
+  string,
+  array,
+  title,
+  description,
+  multiline,
+}
+
+function lookup(fn) {
+  switch (typeof fn) {
+    case 'string':
+      return FNS[fn]();
+    case 'function':
+      return fn;
+    case 'object':
+      if (Array.isArray(fn)) {
+        const [name, options = {}] = fn;
+        return FNS[name](options);
+      }
+  }
+  throw new Error(`Unrecognized decorator/output form: ${fn}`);
+}
+
+// base //
+export function *base({ words = DEFAULT_WORDS, fixedStarts = 0 } = {}) {
+  const wordsLength = words.length;
+  for (let i = 0; ; i++) {
+    yield words[i < fixedStarts ? i : Math.floor(Math.random() * wordsLength)];
+  }
+}
+
+// output //
+export function string({ separator = ' ' } = {}) {
+  return iterator => [...iterator].join(separator);
+}
+
+export function array() {
+  return iterator => [...iterator];
+}
+
+export function multiline({
+  wordsPerLine = {
+    avg: 10,
+    std: 3,
+    min: 1,
+  },
+} = {}) {
+  return iterator => {
+    let slen = gaussMS(wordsPerLine);
+    let result = '';
+    for (let word of iterator) {
+      if (result) {
+        if (slen-- === 0) {
+          result += '\n';
+          slen = gaussMS(wordsPerLine);
+        } else {
+          result += ' ';
+        }
+      }
+      result += word;
+    }
+    return result;
+  }
+}
+
+// decorators //
+export function limit(size = [5, 10]) {
+  const n = typeof size === 'number' ? size : randomInt(...size);
+  return function *(iterator) {
+    let i = 0;
+    for (let word of iterator) {
+      if (i++ >= n) {
+        break;
+      }
+      yield word;
+    }
+  };
+}
+
+export function title({} = {}) {
+  return function *(iterator) {
+    for (let word of iterator) {
+      yield capitalize(word);
+    }
+  };
+}
+
+export function description({
+  wordsPerSentence = {
+    avg: 24,
+    std: 5,
+    min: 1,
+  },
+  punctuation = '.',
+} = {}) {
+  return function *(iterator) {
+    let slen = 0;
+
+    yield* iterateWithLastItemSignal(iterator, function *(word, last) {
+      if (slen === 0) {
+        word = capitalize(word);
+        slen = gaussMS(wordsPerSentence);
+      }
+      if (--slen === 0 || last) {
+        word += punctuation;
+      }
+      yield word;
+    });
+  };
+}
+
+// helpers //
+function capitalize(word) {
+  return word[0].toUpperCase() + word.substring(1);
+}
+
+// TODO: have a random variable expression
+function gaussMS(args) {
+  if (typeof args === 'number') {
+    return Math.round(avg);
+  }
+  let { avg, std, min, max } = args;
+  if (std === undefined) {
+    std = avg / 4;
+  }
+  let n = gaussRandom() * std + avg;
+  if (min !== undefined) {
+    n = Math.max(min, n);
+  }
+  if (max !== undefined) {
+    n = Math.min(max, n);
+  }
+  return Math.round(n);
+}

package/lib/markdown.js

@@ -0,0 +1,313 @@
+import { randomInt, imageUrl, shuffle, iterateWithLastItemSignal } from './utils.js';
+import * as lorem from './lorem.js';
+import * as languages from './languages.js';
+
+// TODO: wild mode that generates edge cases
+
+function extractLangFeatures(features = []) {
+  const languages = new Set();
+  const rest = [];
+  for (const feature of features) {
+    if (feature.startsWith('lang-')) {
+      let lang = feature.slice(5);
+      if (lang === 'javascript') {
+        lang = 'js';
+      }
+      languages.add(lang);
+    } else {
+      rest.push(feature);
+    }
+  }
+  return [[...languages], rest];
+}
+
+export function markdown({ sources, citation, features, blocks = [8, 12], sampling = 1 } = {}) {
+  let languages = [];
+  [languages, features] = extractLangFeatures(features);
+  // TODO: block features
+  let result = sample([
+    () => atxHeading({ features }),
+    () => paragraph({ sources, citation, features }),
+    ...languages.map(lang => () => fencedCodeBlock({ lang, features })),
+    ...(languages.length ? [] : [() => fencedCodeBlock({ features })]),
+    () => paragraph({ sources, citation, features }),
+    () => table({ features }),
+    () => image(),
+    () => paragraph({ sources, citation, features }),
+    () => hr(),
+    () => html(),
+    () => atxHeading({ features }),
+    () => paragraph({ sources, citation, features }),
+    () => list({ features }),
+    () => paragraph({ sources, citation, features }),
+  ], sampling).join('\n\n');
+  if (citation && citation.unused && citation.unused.length) {
+    // flush all unused citations
+    const indicies = [...citation.unused];
+    indicies.sort((a, b) => a - b);
+    result += indicies.map(index => _citation(citation, sources[index])).join('');
+  }
+  return result;
+}
+
+function sample(fns, sampling) {
+  const arr = [];
+  for (const fn of fns) {
+    if (sampling >= 1 || Math.random() < sampling) {
+      arr.push(fn());
+    }
+  }
+  return arr;
+}
+
+// leaf blocks //
+export function hr() {
+  // wild mode: while spaces at the beginning (< 4), in between, in the end
+  // wild mode: no line break for '*'
+  return '*-_'.charAt(randomInt(0, 2)).repeat(randomInt(3, 6));
+}
+
+export function atxHeading({ features, level = [1, 6], size = [1, 8], content }) {
+  const words = content || lorem.lorem({ size });
+  return `${'#'.repeat(randomInt(...level))} ${words}`;
+}
+
+export function setextHeading({ features, level = [1, 2], size = [1, 8], content }) {
+  const words = content || lorem.lorem({ size });
+  return `${words}\n${'=-'.charAt(randomInt(...level) - 1).repeat(3)}`;
+}
+
+export function linkReferenceDefinition({ label, destination, title }) {
+  return `[${label}]: ${destination}${title !== undefined ? ` ${title}` : ''}`;
+}
+
+export function indentedCodeBlock({ lang, content, size }) {
+  content = content || codeContent({ lang, size }); 
+  return indent(4, content);
+}
+
+export function fencedCodeBlock({ lang, content, size, fenceChar = '`' }) {
+  if (fenceChar === 'random') {
+    fenceChar = '`~'.charAt(randomInt(0, 1));
+  }
+  content = content || codeContent({ lang, size }); 
+  // TODO: escape fenceChar in content
+  return `${fenceChar.repeat(3)}${lang || ''}\n${content}\n${fenceChar.repeat(3)}`;
+}
+
+export function paragraph({ sources, citation, features, size = [20, 50] }) {
+  // force all inline features
+  const decorates = ['description', decorateInlineFeatures()];
+  if (sources && citation) {
+    decorates.push(decorateCitation(sources, citation));
+  }
+  return lorem.lorem({ size, decorates });
+}
+
+export function table({ features, columns = [2, 4], rows = [2, 8] }) {
+  columns = randomInt(...columns);
+  rows = randomInt(...rows);
+  const defs = [...multiply({ size: 1 }, columns - 1), { size: [3, 8] }];
+  const header = lorem.lorem({ size: columns, output: 'array' });
+  const delimiter = defs.map(() => '---');
+  const body = [ header, delimiter ];
+  for (let i = 0; i < rows - 1; i++) {
+    body.push(defs.map(({ size }) => lorem.lorem({ size })));
+  }
+  return body.map(tableRow).join('\n');
+}
+
+export function image({ url, imageSize = [400, 250], ...options } = {}) {
+  url = url || imageUrl(imageSize);
+  return `![${_content(options)}](${url})`;
+}
+
+// container blocks //
+export function blockquote({ features, size = [3, 5] }) {
+  // TODO
+  return _blockquote(lorem.lorem({ size }));
+}
+
+const LIST_ITEM_TYPES = ['ordered', 'bullet', 'task'];
+
+export function list({ features, type = 'random', count = [1, 8], size = [5, 15] }) {
+  count = typeof count === 'number' ? count : randomInt(...count);
+  const t = type === 'random' ? LIST_ITEM_TYPES[Math.floor(3 * Math.random())] : type;
+  const items = [];
+  while (count > 0) {
+    const c = randomInt(1, count);
+    let content = paragraph({ features, size });
+    if (c > 1) {
+      content += `\n${list({ features, type, count: c - 1, size })}`;
+    }
+    items.push(listItem(t, content));
+    count -= c;
+  }
+  return items.join('\n');
+}
+
+// inline //
+export function codeSpan(options) {
+  return `\`${_content(options)}\``;
+}
+
+export function emphasis({ level = [1, 3], options }) {
+  level = typeof level === 'number' ? level : randomInt(...level);
+  const str = '_*'.charAt(randomInt(0, 1)).repeat(level);
+  return `${str}${_content(options)}${str}`;
+}
+
+export function link({ url = 'https://miso.ai', ...options } = {}) {
+  return `[${_content(options)}](${url})`;
+}
+
+export function html({} = {}) {
+  return `<div>${svg()}</div>`;
+}
+
+function svg() {
+  return `<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" fill="currentColor" class="bi bi-calculator" viewBox="0 0 16 16"><path d="M12 1a1 1 0 0 1 1 1v12a1 1 0 0 1-1 1H4a1 1 0 0 1-1-1V2a1 1 0 0 1 1-1zM4 0a2 2 0 0 0-2 2v12a2 2 0 0 0 2 2h8a2 2 0 0 0 2-2V2a2 2 0 0 0-2-2z"/><path d="M4 2.5a.5.5 0 0 1 .5-.5h7a.5.5 0 0 1 .5.5v2a.5.5 0 0 1-.5.5h-7a.5.5 0 0 1-.5-.5zm0 4a.5.5 0 0 1 .5-.5h1a.5.5 0 0 1 .5.5v1a.5.5 0 0 1-.5.5h-1a.5.5 0 0 1-.5-.5zm0 3a.5.5 0 0 1 .5-.5h1a.5.5 0 0 1 .5.5v1a.5.5 0 0 1-.5.5h-1a.5.5 0 0 1-.5-.5zm0 3a.5.5 0 0 1 .5-.5h1a.5.5 0 0 1 .5.5v1a.5.5 0 0 1-.5.5h-1a.5.5 0 0 1-.5-.5zm3-6a.5.5 0 0 1 .5-.5h1a.5.5 0 0 1 .5.5v1a.5.5 0 0 1-.5.5h-1a.5.5 0 0 1-.5-.5zm0 3a.5.5 0 0 1 .5-.5h1a.5.5 0 0 1 .5.5v1a.5.5 0 0 1-.5.5h-1a.5.5 0 0 1-.5-.5zm0 3a.5.5 0 0 1 .5-.5h1a.5.5 0 0 1 .5.5v1a.5.5 0 0 1-.5.5h-1a.5.5 0 0 1-.5-.5zm3-6a.5.5 0 0 1 .5-.5h1a.5.5 0 0 1 .5.5v1a.5.5 0 0 1-.5.5h-1a.5.5 0 0 1-.5-.5zm0 3a.5.5 0 0 1 .5-.5h1a.5.5 0 0 1 .5.5v4a.5.5 0 0 1-.5.5h-1a.5.5 0 0 1-.5-.5z"/></svg>`;
+}
+
+// TODO: ref link
+// TODO: autolink
+// TODO: hard line break
+
+const INLINE_FEATURES = {
+  'code-span': () => ['`', '`'],
+  'emphasis-1': () => multiply(_emphasisAdfix(1), 2),
+  'emphasis-2': () => multiply(_emphasisAdfix(2), 2),
+  'emphasis-3': () => multiply(_emphasisAdfix(3), 2),
+  'strikethrough': () => ['~', '~'],
+  'link': ({ url = 'https://miso.ai' } = {}) => [`[`, `](${url})`],
+};
+
+function _emphasisAdfix(level = [1, 3]) {
+  level = typeof level === 'number' ? level : randomInt(...level);
+  return '_*'.charAt(randomInt(0, 1)).repeat(level);
+}
+
+const INLINE_FEATURE_LIST = Object.keys(INLINE_FEATURES);
+const INLINE_FEATURE_SET = new Set(INLINE_FEATURE_LIST);
+
+// decorator //
+export function decorateInlineFeatures({ features = INLINE_FEATURE_LIST, size = [1, 3], rest = [0, 8] } = {}) {
+  features = features.filter(f => INLINE_FEATURE_SET.has(f));
+
+  const unused = shuffle([...features]);
+  let unusedCursor = unused.length - 1;
+
+  const rollRest = () => typeof rest === 'number' ? rest : randomInt(...rest);
+  const rollFeatureSize = () => typeof size === 'number' ? size : randomInt(...size);
+  const rollFeatureType = () => unusedCursor >= 0 ? unused[unusedCursor--] : features[randomInt(0, features.length - 1)];
+
+  return function *(iterator) {
+    let count = rollRest();
+    let suffix;
+
+    yield *iterateWithLastItemSignal(iterator, function *(word, last) {
+      // prefix if necessary
+      if (!suffix && count === 0) {
+        const [prefix, s] = INLINE_FEATURES[rollFeatureType()]();
+        word = `${prefix}${word}`;
+        count = rollFeatureSize();
+        suffix = s;
+      }
+
+      // consume word count
+      count--;
+
+      // suffix if necessary
+      if (suffix) {
+        const len = word.length;
+        const lastChar = word.charAt(len - 1);
+        if (isPunctuation(lastChar)) {
+          word = `${word.substring(0, len - 1)}${suffix}${lastChar}`;
+          suffix = undefined;
+          count = rollRest();
+        } else if (last || count === 0) {
+          word = `${word}${suffix}`;
+          suffix = undefined;
+          count = rollRest();
+        }
+      }
+
+      // output
+      yield word;
+    });
+  };
+}
+
+export function decorateCitation(sources, { density = 0.667, unused, ...options }) {
+  const sourceLength = sources.length;
+  const rollIndex = () => unused && unused.length ? unused.pop() : randomInt(0, sourceLength - 1);
+
+  return function *(iterator) {
+    for (const word of iterator) {
+      // not ended with alphabet or number -> last word in sentence
+      if (word.charAt(word.length - 1) === '.' && Math.random() < density) {
+        yield `${word}${_citation(options, sources[rollIndex()])}`;
+      } else {
+        yield word;
+      }
+    }
+  };
+}
+
+// helper //
+function _content({ size = [1, 3], content } = {}) {
+  return content || lorem.lorem({ size });
+}
+
+function _blockquote(content) {
+  return content.split('\n').map(line => `> ${line}`).join('\n');
+}
+
+export function indent(size, content) {
+  return content.split('\n').map(line => ' '.repeat(size) + line).join('\n');
+}
+
+export function listItem(type, content) {
+  const [firstLine, restLines] = content.split('\n', 2);
+  const result = `${listItemPrefix(type)} ${firstLine}`;
+  const indentSize = type === 'ordered' ? 3 : 2;
+  return !restLines ? result : result + `\n${indent(indentSize, restLines)}`;
+}
+
+function listItemPrefix(type, checked = 'random') {
+  switch (type) {
+    case 'ordered':
+      return '1.';
+    case 'bullet':
+      return '-';
+    case 'task':
+      const mark = (checked === 'random' ? Math.random() < 0.5 : !!checked) ? 'x' : ' ';
+      return `- [${mark}]`;
+    default:
+      throw new Error(`unknown list item type: ${type}`);
+  }
+}
+
+function codeContent({ lang, size = [10, 30] }) {
+  return lang && languages[lang] ? languages[lang]() : lorem.lorem({ output: 'multiline', size });
+}
+
+function tableRow(cells) {
+  return `| ${cells.join(' | ')} |`;
+}
+
+function multiply(obj, i) {
+  const arr = [];
+  for (let j = 0; j < i; j++) {
+    arr.push(typeof obj === 'function' ? obj() : obj);
+  }
+  return arr;
+}
+
+function isPunctuation(char) {
+  return char === '.' || char === ',' || char === '!' || char === '?' || char === ':' || char === ';';
+}
+
+function _citation({ link, start, end }, { index, url }) {
+  return link ? `[${start}${index}${end}](${url})` : `${start}${index}${end}`;
+}

package/lib/utils.js

@@ -0,0 +1,73 @@
+export function uuid() {
+  return ([1e7]+-1e3+-4e3+-8e3+-1e11).replace(/[018]/g, a => (a ^ Math.random() * 16 >> a / 4).toString(16));
+}
+
+export function randomInt(min, max) {
+  return max == null || (max <= min) ? min : (min + Math.floor(Math.random() * (max - min + 1)));
+}
+
+// TODO: pass in size
+export function repeat(fn, range) {
+  const n = randomInt(...range);
+  const result = [];
+  for (let i = 0; i < n; i++) {
+    result.push(fn());
+  }
+  return result;
+}
+
+export function id() {
+  return Math.random().toString(36).substring(2, 10);
+}
+
+export function shuffle(array) {
+  for (let i = array.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [array[i], array[j]] = [array[j], array[i]];
+  }
+  return array;
+}
+
+export function imageUrl(size) {
+  const seed = Math.floor(Math.random() * 1000);
+  const sizePath = Array.isArray(size) ? size.length > 1 ? `${size[0]}/${size[1]}` : `${size[0]}` : `${size}`;
+  return `https://picsum.photos/seed/${seed}/${sizePath}`;
+}
+
+export function formatDatetime(timestamp) {
+  const str = new Date(timestamp).toISOString();
+  return str.endsWith('Z') ? str.slice(0, -1) : str;
+}
+
+export function sample(size, sampling) {
+  return sampling !== undefined ? Math.ceil(size * sampling) : size;
+}
+
+export function gaussRandom() {
+  return uniformRandom() + uniformRandom() + uniformRandom();
+}
+
+export function rollLatency(min, max) {
+  return (min + max) / 2 + gaussRandom() * (max - min) / 6;
+}
+
+function uniformRandom() {
+  return Math.random() * 2 - 1;
+}
+
+export function *iterateWithLastItemSignal(iterator, fn) {
+  let last;
+  for (const item of iterator) {
+    if (last) {
+      yield* fn(last);
+    }
+    last = item;
+  }
+  if (last) {
+    yield* fn(last, true);
+  }
+}
+
+export function excludeHtml({ html, ...rest }) {
+  return rest;
+}

package/lib/words.js

@@ -0,0 +1,182 @@
+
+// genereated by bin/data.js
+export default [
+  "lorem",
+  "ipsum",
+  "dolor",
+  "sit",
+  "amet",
+  "consectetur",
+  "adipiscing",
+  "elit",
+  "curabitur",
+  "vel",
+  "hendrerit",
+  "libero",
+  "eleifend",
+  "blandit",
+  "nunc",
+  "ornare",
+  "odio",
+  "ut",
+  "orci",
+  "gravida",
+  "imperdiet",
+  "nullam",
+  "purus",
+  "lacinia",
+  "a",
+  "pretium",
+  "quis",
+  "congue",
+  "praesent",
+  "sagittis",
+  "laoreet",
+  "auctor",
+  "mauris",
+  "non",
+  "velit",
+  "eros",
+  "dictum",
+  "proin",
+  "accumsan",
+  "sapien",
+  "nec",
+  "massa",
+  "volutpat",
+  "venenatis",
+  "sed",
+  "eu",
+  "molestie",
+  "lacus",
+  "quisque",
+  "porttitor",
+  "ligula",
+  "dui",
+  "mollis",
+  "tempus",
+  "at",
+  "magna",
+  "vestibulum",
+  "turpis",
+  "ac",
+  "diam",
+  "tincidunt",
+  "id",
+  "condimentum",
+  "enim",
+  "sodales",
+  "in",
+  "hac",
+  "habitasse",
+  "platea",
+  "dictumst",
+  "aenean",
+  "neque",
+  "fusce",
+  "augue",
+  "leo",
+  "eget",
+  "semper",
+  "mattis",
+  "tortor",
+  "scelerisque",
+  "nulla",
+  "interdum",
+  "tellus",
+  "malesuada",
+  "rhoncus",
+  "porta",
+  "sem",
+  "aliquet",
+  "et",
+  "nam",
+  "suspendisse",
+  "potenti",
+  "vivamus",
+  "luctus",
+  "fringilla",
+  "erat",
+  "donec",
+  "justo",
+  "vehicula",
+  "ultricies",
+  "varius",
+  "ante",
+  "primis",
+  "faucibus",
+  "ultrices",
+  "posuere",
+  "cubilia",
+  "curae",
+  "etiam",
+  "cursus",
+  "aliquam",
+  "quam",
+  "dapibus",
+  "nisl",
+  "feugiat",
+  "egestas",
+  "class",
+  "aptent",
+  "taciti",
+  "sociosqu",
+  "ad",
+  "litora",
+  "torquent",
+  "per",
+  "conubia",
+  "nostra",
+  "inceptos",
+  "himenaeos",
+  "phasellus",
+  "nibh",
+  "pulvinar",
+  "vitae",
+  "urna",
+  "iaculis",
+  "lobortis",
+  "nisi",
+  "viverra",
+  "arcu",
+  "morbi",
+  "pellentesque",
+  "metus",
+  "commodo",
+  "ut",
+  "facilisis",
+  "felis",
+  "tristique",
+  "ullamcorper",
+  "placerat",
+  "aenean",
+  "convallis",
+  "sollicitudin",
+  "integer",
+  "rutrum",
+  "duis",
+  "est",
+  "etiam",
+  "bibendum",
+  "donec",
+  "pharetra",
+  "vulputate",
+  "maecenas",
+  "mi",
+  "fermentum",
+  "consequat",
+  "suscipit",
+  "aliquam",
+  "habitant",
+  "senectus",
+  "netus",
+  "fames",
+  "quisque",
+  "euismod",
+  "curabitur",
+  "lectus",
+  "elementum",
+  "tempor",
+  "risus",
+  "cras"
+];

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@miso.ai/lorem",
+  "description": "Lorem support for doggoganger",
+  "type": "module",
+  "main": "lib/index.js",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "generate:data": "node ./bin/data.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MisoAI/doggoganger.git"
+  },
+  "homepage": "https://github.com/MisoAI/doggoganger/",
+  "license": "MIT",
+  "contributors": [
+    "simonpai <simon.pai@askmiso.com>"
+  ],
+  "bugs": {
+    "url": "https://github.com/MisoAI/doggoganger/issues"
+  },
+  "devDependencies": {
+    "js-yaml": "^4.1.0"
+  },
+  "version": "0.0.1"
+}

package/package.json.bak

@@ -0,0 +1,27 @@
+{
+  "name": "@miso.ai/lorem",
+  "description": "Lorem support for doggoganger",
+  "type": "module",
+  "main": "lib/index.js",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "generate:data": "node ./bin/data.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MisoAI/doggoganger.git"
+  },
+  "homepage": "https://github.com/MisoAI/doggoganger/",
+  "license": "MIT",
+  "contributors": [
+    "simonpai <simon.pai@askmiso.com>"
+  ],
+  "bugs": {
+    "url": "https://github.com/MisoAI/doggoganger/issues"
+  },
+  "devDependencies": {
+    "js-yaml": "^4.1.0"
+  }
+}